import { appConfig } from './config/app-config.js';
import { ENV_CONFIG } from './config/env-config.js';

// 导入WebXR音频解决方案
import webXRAudioSolution from './core/WebXRAudioSolution.js';

// 导入音频上下文单例
import audioContextSingleton from './core/audio-context-singleton.js';

export class VoiceManager {
    constructor(apiBaseUrl = null) {
        // 使用配置文件中的API地址，如果没有传入参数的话
        this.apiBaseUrl = apiBaseUrl || appConfig.getApiUrl();
        this.recognition = null;
        this.synthesis = window.speechSynthesis;
        this.isListening = false;
        this.isConnected = false;
        this.isSpeaking = false;
        this.isInitialized = false;
        this._isStarting = false;
        
        // 核心修复：添加音频上下文管理
        this.audioContext = null;
        this.audioContextInitialized = false;
        this.audioContextSuspended = true;
        
        // 用于跟踪TTS是否已通过用户交互初始化
        this.ttsInitialized = false;
        
        // 新增状态变量用于语音监控和恢复协调
        this._lastSpeechStartTime = 0; // 上次语音开始时间
        this._isRecovering = false;    // 是否正在恢复过程中
        this._isStarting = false;      // 是否正在启动语音识别过程中
        
        // 语音识别配置
        this.recognitionConfig = {
            lang: 'zh-CN',
            continuous: false,
            interimResults: false,
            maxAlternatives: 1
        };
        
        // 语音合成配置
        this.synthesisConfig = {
            lang: 'zh-CN',
            rate: 1.0,
            pitch: 1.0,
            volume: 1.0
        };
        
        // 回调函数
        this.callbacks = {
            onResult: null,
            onError: null,
            onStart: null,
            onEnd: null,
            onConnectionChange: null
        };
        
        this.init();
    }

    /**
     * 初始化语音管理器
     */
    async init() {
        await this.initSpeechRecognition();
        await this.checkAPIConnection();
        this.setupSpeechSynthesis();
        
        // 初始化音频上下文（关键点）
        await this.initAudioContext();
        
        // 检查并集成WebXR音频解决方案
        if (window._webXRAudioSolution) {
            this.webXRAudioSolution = window._webXRAudioSolution;
            console.log('✅ 语音管理器已集成WebXR音频解决方案');
        }
        
        // 设置语音合成诊断系统
        this.setupSpeechDiagnostics();
        console.log('✅ 语音合成诊断系统已启用');
        
        // 设置用户交互监听以初始化TTS
        this.setupUserInteraction();
        console.log('✅ 用户交互监听已设置');
        
        this.isInitialized = true;
        console.log('✅ 语音管理器初始化完成');
    }
    
    /**
     * 激活WebXR模式下的语音功能
     */
    activateWebXRMode() {
        try {
            console.log('激活WebXR模式语音功能...');
            
            // 确保音频上下文处于活动状态
            this.ensureAudioActive();
            
            // 如果WebXR音频解决方案可用，通知其激活
            if (this.webXRAudioSolution) {
                this.webXRAudioSolution.activate();
            }
            
            // 启动语音识别
            this.startListening();
            
            this.isWebXRModeActive = true;
            
            console.log('WebXR模式语音功能激活完成');
        } catch (error) {
            console.error('激活WebXR模式语音功能失败:', error);
        }
    }
    
    /**
     * 停用WebXR模式下的语音功能
     */
    deactivateWebXRMode() {
        try {
            console.log('停用WebXR模式语音功能...');
            
            // 停止语音识别
            this.stopListening();
            
            // 如果WebXR音频解决方案可用，通知其停用
            if (this.webXRAudioSolution) {
                this.webXRAudioSolution.deactivate();
            }
            
            this.isWebXRModeActive = false;
            
            console.log('WebXR模式语音功能停用完成');
        } catch (error) {
            console.error('停用WebXR模式语音功能失败:', error);
        }
    }
    
    /**
     * 初始化音频上下文（核心修复）
     * 创建一个持久化的音频上下文用于整个应用生命周期
     */
    async initAudioContext() {
        console.log('🔊 初始化音频上下文');
        
        try {
            // 使用音频上下文单例
            this.audioContext = audioContextSingleton.getContext({
                sampleRate: 48000,
                latencyHint: 'interactive'
            });
            this.audioContextInitialized = true;
            
            // 尝试立即恢复
            await audioContextSingleton.resume();
            this.audioContextSuspended = this.audioContext.state !== 'running';
            
            console.log(`✅ 音频上下文初始化成功，当前状态: ${this.audioContext.state}`);
            return true;
        } catch (error) {
            console.error('❌ 初始化音频上下文失败:', error);
            return false;
        }
    }
    
    /**
     * 确保音频上下文处于活动状态（增强版本）
     * @returns {boolean} 音频是否成功激活
     */
    async ensureAudioActive() {
        console.log('🔊 确保音频上下文处于活动状态');
        
        try {
            // 优先使用AudioPermissionManager管理音频上下文
            if (window.app?.audioPermissionManager) {
                console.log('🎯 使用AudioPermissionManager确保音频活动');
                const success = await window.app.audioPermissionManager.ensureAudioContextRunning();
                if (success) {
                    // 获取共享的音频上下文
                    this.audioContext = window.app.audioPermissionManager.getAudioContext();
                    this.audioContextInitialized = true;
                    this.audioContextSuspended = false;
                    console.log('✅ 通过AudioPermissionManager激活音频上下文');
                    return true;
                } else {
                    console.warn('⚠️ AudioPermissionManager激活失败，回退到传统方法');
                }
            }
            
            // 如果没有AudioPermissionManager或失败，使用自己的音频上下文
            if (!this.audioContextInitialized) {
                await this.initAudioContext();
            }
            
            // 尝试恢复音频上下文
            if (this.audioContext && this.audioContext.state === 'suspended') {
                console.log('🔊 尝试恢复音频上下文');
                await this.audioContext.resume();
                this.audioContextSuspended = false;
                console.log('✅ 音频上下文恢复成功');
                return true;
            }
            
            return !this.audioContextSuspended;
        } catch (error) {
            console.error('❌ 确保音频上下文活动失败:', error);
            return false;
        }
    }
    
    /**
     * 设置语音合成诊断系统
     */
    setupSpeechDiagnostics() {
        if (!this.synthesis) return;
        
        // 监听语音合成状态变化
        this.synthesis.onvoiceschanged = () => {
            console.log('🔊 语音列表已更新');
            this.getAvailableVoices();
        };
        
        // 监控语音合成错误
        this.synthesis.onerror = (event) => {
            console.error('❌ 语音合成错误:', event.error);
            
            // 尝试恢复语音合成系统
            this.attemptTTSRecovery(event.error);
        };
    }
    
    /**
     * 尝试恢复语音合成系统
     */
    async attemptTTSRecovery(error) {
        if (this._isRecovering) return;
        
        this._isRecovering = true;
        console.log('🔄 尝试恢复语音合成系统，错误:', error);
        
        try {
            // 1. 确保音频上下文处于活动状态
            await this.ensureAudioActive();
            
            // 2. 刷新语音合成系统
            if ('cancel' in this.synthesis) {
                this.synthesis.cancel();
            }
            
            // 3. 重新初始化TTS
            this.ttsInitialized = false;
            await this.initializeTTS();
            
            console.log('✅ 语音合成系统恢复成功');
        } catch (recoveryError) {
            console.error('❌ 语音合成系统恢复失败:', recoveryError);
        } finally {
            this._isRecovering = false;
        }
    }
    
    /**
     * 设置用户交互监听以初始化TTS
     */
    setupUserInteraction() {
        const handleUserInteraction = async () => {
            if (!this.ttsInitialized) {
                await this.initializeTTS();
            }
            
            // 移除事件监听器
            document.removeEventListener('click', handleUserInteraction);
            document.removeEventListener('touchstart', handleUserInteraction);
            document.removeEventListener('keydown', handleUserInteraction);
        };
        
        // 添加多种用户交互事件监听器
        document.addEventListener('click', handleUserInteraction);
        document.addEventListener('touchstart', handleUserInteraction);
        document.addEventListener('keydown', handleUserInteraction);
    }
    
    /**
     * 初始化TTS（通过用户交互触发）
     */
    async initializeTTS() {
        try {
            console.log('🔊 初始化TTS系统');
            
            // 确保音频上下文处于活动状态
            await this.ensureAudioActive();
            
            // 播放一个短暂的静音音频片段来激活TTS
            const utterance = new SpeechSynthesisUtterance('');
            utterance.lang = 'zh-CN';
            utterance.volume = 0;
            utterance.rate = 1.0;
            
            // 使用Promise包装，以便可以等待完成
            return new Promise((resolve) => {
                utterance.onend = () => {
                    this.ttsInitialized = true;
                    console.log('✅ TTS系统已初始化');
                    resolve(true);
                };
                
                utterance.onerror = (event) => {
                    console.warn('⚠️ TTS初始化尝试失败，但继续:', event.error);
                    resolve(false);
                };
                
                this.synthesis.speak(utterance);
            });
        } catch (error) {
            console.error('❌ TTS初始化失败:', error);
            return false;
        }
    }

    /**
     * 初始化语音识别
     */
    async initSpeechRecognition() {
        if (!('webkitSpeechRecognition' in window) && !('SpeechRecognition' in window)) {
            console.warn('浏览器不支持语音识别');
            return;
        }

        const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
        this.recognition = new SpeechRecognition();
        
        // 配置语音识别
        Object.assign(this.recognition, this.recognitionConfig);
        
        // 绑定事件
        this.recognition.onstart = () => {
            this.isListening = true;
            this._isStarting = false; // 重置启动中标志
            console.log('语音识别开始');
            
            // 使用新的事件系统
            this._dispatchEvent('recognitionStart');
            
            if (this.callbacks.onStart) {
                this.callbacks.onStart();
            }
        };
        
        this.recognition.onresult = (event) => {
            const result = event.results[0][0];
            const transcript = result.transcript;
            const confidence = result.confidence;
            
            console.log('语音识别结果:', transcript, '置信度:', confidence);
            
            // 使用新的事件系统
            this._dispatchEvent('recognitionResult', { text: transcript, confidence });
            
            if (this.callbacks.onResult) {
                this.callbacks.onResult(transcript, confidence);
            }
        };
        
        this.recognition.onend = () => {
            // 检查是否在XR模式下
            const isXRMode = this.isWebXRModeActive || (window.app?.immersiveExperience?.isXRActive) || (window.app?.unifiedXRManager?.isXRActive);
            
            // 更新状态
            this.isListening = false;
            console.log('🔚 语音识别结束');
            
            // 使用新的事件系统
            this._dispatchEvent('recognitionEnd');
            
            // 清除超时计时器
            if (this.recognitionTimeout) {
                clearTimeout(this.recognitionTimeout);
                this.recognitionTimeout = null;
            }
            
            // 如果是XR模式，不要完全停止，而是准备重新启动
            if (isXRMode) {
                console.log('🔄 XR模式：语音识别结束，准备下一轮对话');
                // 这里不停止语音输入，等待TTS完成后自动重启
            } else {
                // 检查是否需要自动重新开始（仅在continuous模式下）
                if (this.recognition.continuous) {
                    // 添加短暂延迟避免立即重启造成的资源消耗
                    setTimeout(() => {
                        if (!this.isListening) {
                            console.log('🔄 连续模式下自动重新开始语音识别');
                            this.startListening();
                        }
                    }, 500);
                }
            }
            
            if (this.callbacks.onEnd) {
                this.callbacks.onEnd();
            }
        };
        
        this.recognition.onerror = (event) => {
            // 确保状态标志重置
            this.isListening = false;
            this._isStarting = false;
            
            console.error('语音识别错误:', event.error);
            
            // 特殊处理aborted错误，这是连续对话失败的主要原因之一
            if (event.error === 'aborted') {
                console.log('🔄 检测到aborted错误，执行状态重置...');
                this._safeStopAndReset().then(() => {
                    // 在XR模式下，尝试重新启动
                    const isXRMode = this.isWebXRModeActive || (window.app?.immersiveExperience?.isXRActive) || (window.app?.unifiedXRManager?.isXRActive);
                    if (isXRMode && !this.isSpeaking) {
                        console.log('🔄 XR模式：aborted错误后自动重启语音识别');
                        setTimeout(() => this.startListening(), 800);
                    }
                });
            }
            
            // 使用新的事件系统
            this._dispatchEvent('recognitionError', { error: event.error });
            
            if (this.callbacks.onError) {
                this.callbacks.onError(event.error);
            }
        };
        
        this.recognition.onnomatch = () => {
            console.warn('语音识别无匹配结果');
        };
        
        this.recognition.onsoundstart = () => {
            console.log('检测到声音');
        };
        
        this.recognition.onsoundend = () => {
            console.log('声音结束');
        };
    }

    /**
     * 设置语音合成
     */
    setupSpeechSynthesis() {
        if (!this.synthesis) {
            console.warn('浏览器不支持语音合成');
            return;
        }
        
        // 获取可用的语音
        this.getAvailableVoices();
        
        // 监听语音列表变化
        this.synthesis.onvoiceschanged = () => {
            this.getAvailableVoices();
        };
    }

    /**
     * 获取可用的语音列表
     */
    getAvailableVoices() {
        const voices = this.synthesis.getVoices();
        this.availableVoices = voices.filter(voice => 
            voice.lang.startsWith('zh') || voice.lang.startsWith('en')
        );
        
        console.log('可用语音:', this.availableVoices.map(v => ({
            name: v.name,
            lang: v.lang,
            gender: v.name.toLowerCase().includes('female') ? 'female' : 'male'
        })));
        
        return this.availableVoices;
    }

    /**
     * 开始语音识别
     */
    async startListening() {
        // 检查语音识别器状态
        if (!this.recognition) {
            console.error('❌ 语音识别器未初始化');
            this._dispatchEvent('recognitionError', { error: '语音识别器未初始化' });
            return false;
        }
        
        // 避免重复启动 - 增强的状态检查机制
        const now = Date.now();
        if (this.isListening) {
            console.warn('⚠️ 语音识别已在运行中，避免重复启动');
            return false;
        }
        
        if (this._isStarting) {
            console.warn('⚠️ 语音识别正在启动中，避免重复启动');
            // 如果启动状态已经持续很长时间，强制重置
            if (this._lastStartAttempt && (now - this._lastStartAttempt > 3000)) {
                console.warn('⚠️ 检测到启动状态异常超过3秒，强制重置启动标志');
                this._isStarting = false;
            } else {
                return false;
            }
        }
        
        // 记录启动尝试时间
        this._lastStartAttempt = now;
        
        // 设置启动中状态
        this._isStarting = true;
        
        try {
            // 强制重置识别器状态
            this._forceResetRecognitionState();
            
            // 启动语音识别前额外检查识别器状态
            if (this.recognition.state && 
                (this.recognition.state === 'started' || this.recognition.state === 'starting')) {
                console.warn('⚠️ 识别器内部状态显示正在运行或启动中，停止当前会话后再尝试');
                await this._safeStopAndReset();
                setTimeout(() => this.startListening(), 500);
                return false;
            }
            
            // 启动语音识别
            console.log('🎤 尝试启动语音识别...');
            this.recognition.start();
            console.log('🎤 语音识别启动命令已发送');
            
            // 添加超时保护
            this._startTimeoutCheck();
            
            return true;
        } catch (error) {
            console.error('❌ 启动语音识别失败:', error);
            this._isStarting = false;
            this._dispatchEvent('recognitionError', { error: error.message });
            
            // 处理常见的状态错误
            if (error.name === 'InvalidStateError' || error.message.includes('Recognition is being started')) {
                console.log('🔄 检测到状态错误，执行完全重置流程...');
                await this._safeStopAndReset();
                setTimeout(() => this.startListening(), 800); // 增加更长延迟以确保状态完全重置
            }
            return false;
        }
    }
    
    /**
     * 强制重置识别器状态
     * 用于清理任何可能的状态不一致
     */
    _forceResetRecognitionState() {
        try {
            // 手动重置内部状态
            if (this.recognition && this.recognition.state && 
                ['started', 'starting'].includes(this.recognition.state)) {
                console.log('🔄 强制重置识别器内部状态');
                this.recognition.abort();
                this.isListening = false;
                this._isStarting = false;
            }
        } catch (e) {
            console.warn('⚠️ 强制重置状态时出错，但继续:', e);
        }
    }
    
    /**
     * 安全停止并重置语音识别器
     * 使用 Promise 包装以支持异步调用
     */
    async _safeStopAndReset() {
        return new Promise((resolve) => {
            try {
                console.log('🔄 执行安全停止和重置...');
                
                // 首先尝试中止
                if (this.recognition) {
                    this.recognition.abort();
                }
                
                // 强制重置所有状态标志
                this.isListening = false;
                this._isStarting = false;
                
                // 清除任何超时
                if (this._startTimeoutId) {
                    clearTimeout(this._startTimeoutId);
                    this._startTimeoutId = null;
                }
                
                // 添加延迟确保状态完全重置
                setTimeout(resolve, 300);
            } catch (e) {
                console.error('⚠️ 安全停止时出错:', e);
                resolve(); // 即使出错也要继续
            }
        });
    }
    
    /**
     * 添加启动超时检查
     */
    _startTimeoutCheck() {
        // 清除之前的超时检查
        if (this._startTimeoutId) {
            clearTimeout(this._startTimeoutId);
        }
        
        // 设置新的超时检查 - 如果3秒内没有开始，认为启动失败
        this._startTimeoutId = setTimeout(() => {
            if (this._isStarting && !this.isListening) {
                console.warn('⚠️ 语音识别启动超时，强制重置状态');
                this._isStarting = false;
                this._safeStopAndReset().then(() => {
                    // 尝试重新启动
                    setTimeout(() => this.startListening(), 500);
                });
            }
        }, 3000);
    }
    
    /**
     * 停止语音识别
     * @param {boolean} force - 是否强制停止
     */
    async stopListening(force = false) {
        // 清除启动超时检查
        if (this._startTimeoutId) {
            clearTimeout(this._startTimeoutId);
            this._startTimeoutId = null;
        }
        
        // 检查是否在XR模式下
        const isXRMode = this.isWebXRModeActive || (window.app?.immersiveExperience?.isXRActive) || (window.app?.unifiedXRManager?.isXRActive);
        
        // 如果是XR模式且正在播放TTS，不要停止语音输入
        if (isXRMode && this.isSpeaking && !force) {
            console.log('🔄 XR模式：TTS播放中，保持语音输入准备状态');
            return;
        }
        
        // 停止逻辑
        if (this.recognition && (this.isListening || this._isStarting || force)) {
            try {
                console.log(`🛑 ${force ? '强制停止' : '停止'}语音识别`);
                
                // 根据当前状态选择合适的停止方法
                if (this.recognition.state === 'starting' || this._isStarting) {
                    console.log('🔄 识别器正在启动中，使用abort方法');
                    this.recognition.abort();
                } else {
                    this.recognition.stop();
                }
                
                console.log('✅ 语音识别停止命令已发送');
            } catch (error) {
                console.warn('停止语音识别时发生错误:', error);
                // 即使出错也要重置状态
                this._forceResetRecognitionState();
            }
        }
        
        // 确保状态标志正确重置
        this.isListening = false;
        this._isStarting = false;
    }
    
    /**
     * 确保语音识别可以正确重启
     * 专门用于XR模式下语音合成结束后的语音识别恢复
     */
    async ensureRecognitionRestart() {
        // 等待语音合成完全结束
        if (this.isSpeaking) {
            console.log('⏳ 等待TTS完成后再重启语音识别');
            setTimeout(() => this.ensureRecognitionRestart(), 500);
            return;
        }
        
        // 执行安全重置
        await this._safeStopAndReset();
        
        // 延迟启动以确保系统状态完全稳定
        setTimeout(() => {
            console.log('🔄 TTS完成后重启语音识别');
            this.startListening().catch(error => {
                console.error('❌ 重启语音识别失败:', error);
                // 失败后再次尝试
                setTimeout(() => this.startListening(), 1000);
            });
        }, 800);
    }
    
    /**
     * 中止语音识别（立即中断）
     */
    abortListening() {
        if (!this.recognition) return;
        
        try {
            console.log('🛑 中止语音识别');
            this.recognition.abort();
        } catch (error) {
            console.warn('⚠️ 中止语音识别时出错:', error);
        } finally {
            // 重置状态标志
            this.isListening = false;
            this._isStarting = false;
        }
    }

    /**
     * 停止语音识别
     */
    /**
     * 停止语音识别
     */
    stopListening() {
        // 检查是否在XR模式下
        const isXRMode = this.isWebXRModeActive || (window.app?.immersiveExperience?.isXRActive) || (window.app?.unifiedXRManager?.isXRActive);
        
        // 如果是XR模式且正在播放TTS，不要停止语音输入
        if (isXRMode && this.isSpeaking) {
            console.log('🔄 XR模式：TTS播放中，保持语音输入准备状态');
            return;
        }
        
        // 原有的停止逻辑
        if (this.recognition && this.isListening) {
            try {
                this.recognition.stop();
                console.log('✅ 语音识别已停止');
            } catch (error) {
                console.warn('停止语音识别时发生错误:', error);
            }
        }
        
        this.isListening = false;
    }

    /**
     * 切换语音识别状态
     */
    toggleListening() {
        if (this.isListening) {
            this.stopListening();
        } else {
            this.startListening();
        }
    }

    /**
     * 添加事件监听器
     */
    addEventListener(type, callback) {
        if (!this._eventListeners) {
            this._eventListeners = new Map();
        }
        if (!this._eventListeners.has(type)) {
            this._eventListeners.set(type, []);
        }
        this._eventListeners.get(type).push(callback);
    }

    /**
     * 移除事件监听器
     */
    removeEventListener(type, callback) {
        if (this._eventListeners && this._eventListeners.has(type)) {
            const listeners = this._eventListeners.get(type);
            const index = listeners.indexOf(callback);
            if (index > -1) {
                listeners.splice(index, 1);
            }
        }
    }

    /**
     * 分发事件
     */
    _dispatchEvent(type, detail = {}) {
        // 触发自定义事件
        const event = new CustomEvent(type, { detail });
        
        // 调用注册的回调函数
        if (this._eventListeners && this._eventListeners.has(type)) {
            this._eventListeners.get(type).forEach(callback => {
                try {
                    callback(event);
                } catch (error) {
                    console.error(`事件监听器错误 (${type}):`, error);
                }
            });
        }
    }

    /**
     * 重启语音监听
     */
    restartListening() {
        try {
            console.log('🔄 重启语音监听');
            
            // 先停止当前监听
            if (this.isListening) {
                this.stopListening();
            }
            
            // 短暂延迟后重新开始
            setTimeout(() => {
                this.startListening();
            }, 100);
            
            return true;
        } catch (error) {
            console.error('重启语音监听失败:', error);
            return false;
        }
    }

    /**
     * 发送消息到AI API
     * @param {string} message - 用户消息
     * @param {string} userId - 用户ID
     * @param {string} sessionId - 会话ID
     * @returns {Promise<Object>} API响应
     */
    async sendMessage(message, userId = 'user_001', sessionId = 'session_001') {
        try {
            const response = await fetch(`${this.apiBaseUrl}/chat`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    message: message,
                    user_id: userId,
                    session_id: sessionId
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data;
        } catch (error) {
            console.error('发送消息失败:', error);
            throw error;
        }
    }

    /**
     * 流式发送消息到AI API
     * @param {string} message - 用户消息
     * @param {Function} onChunk - 接收数据块的回调
     * @param {string} userId - 用户ID
     * @param {string} sessionId - 会话ID
     */
    async sendMessageStream(message, onChunk, userId = 'user_001', sessionId = 'session_001') {
        try {
            const response = await fetch(`${this.apiBaseUrl}/chat/stream`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    message: message,
                    user_id: userId,
                    session_id: sessionId
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const reader = response.body.getReader();
            const decoder = new TextDecoder();

            while (true) {
                const { done, value } = await reader.read();
                if (done) break;

                const chunk = decoder.decode(value);
                const lines = chunk.split('\n');

                for (const line of lines) {
                    if (line.startsWith('data: ')) {
                        const data = line.slice(6);
                        if (data === '[DONE]') {
                            return;
                        }
                        
                        try {
                            const parsed = JSON.parse(data);
                            onChunk(parsed);
                        } catch (e) {
                            console.warn('解析流数据失败:', e);
                        }
                    }
                }
            }
        } catch (error) {
            console.error('流式发送消息失败:', error);
            throw error;
        }
    }

    /**
     * 文本转语音（使用API）
     * @param {string} text - 要转换的文本
     * @param {string} voice - 语音类型
     * @returns {Promise<string>} 音频文件URL
     */
    async textToSpeechAPI(text, voice = 'zhichu') {
        try {
            const response = await fetch(`${this.apiBaseUrl}/tts`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    text: text,
                    voice: voice
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data.audio_url;
        } catch (error) {
            console.error('API语音合成失败:', error);
            throw error;
        }
    }

    /**
     * 文本转语音（使用浏览器）
     * @param {string} text - 要转换的文本
     * @param {Object} options - 语音选项
     * @returns {Promise<void>}
     */
    async textToSpeechBrowser(text, options = {}) {
        if (!this.synthesis) {
            throw new Error('浏览器不支持语音合成');
        }

        // 记录开始时间
        this._lastSpeechStartTime = Date.now();
        this.isSpeaking = true;
        
        // 使用新的事件系统
        this._dispatchEvent('speechStart', { text, options });

        return new Promise((resolve, reject) => {
            const utterance = new SpeechSynthesisUtterance(text);
            
            // 设置语音参数
            utterance.lang = options.lang || this.synthesisConfig.lang;
            utterance.rate = options.rate || this.synthesisConfig.rate;
            utterance.pitch = options.pitch || this.synthesisConfig.pitch;
            utterance.volume = options.volume || this.synthesisConfig.volume;
            
            // 选择语音
            if (options.voice && this.availableVoices) {
                const voice = this.availableVoices.find(v => 
                    v.name === options.voice || v.lang === options.voice
                );
                if (voice) {
                    utterance.voice = voice;
                }
            }
            
            utterance.onend = () => {
                this.isSpeaking = false;
                // 使用新的事件系统
                this._dispatchEvent('speechEnd', { text });
                resolve();
            };
            utterance.onerror = (event) => {
                this.isSpeaking = false;
                // 使用新的事件系统
                this._dispatchEvent('speechError', { error: event.error });
                reject(event.error);
            };
            
            // 如果提供了回调，在TTS开始播放时触发基于固定时间间隔的字幕显示
            if (options.onStart && typeof options.onStart === 'function') {
                // 延迟一点时间以确保字幕显示与语音同步
                setTimeout(() => {
                    options.onStart(text);
                }, 100);
            }
            
            this.synthesis.speak(utterance);
        });
    }

    /**
     * 播放音频文件
     * @param {string} audioUrl - 音频文件URL
     * @returns {Promise<void>}
     */
    async playAudio(audioUrl) {
        return new Promise((resolve, reject) => {
            const audio = new Audio(audioUrl);
            
            audio.onended = () => resolve();
            audio.onerror = (error) => reject(error);
            
            audio.play().catch(reject);
        });
    }

    /**
     * 分析文本情绪
     * @param {string} text - 要分析的文本
     * @returns {Promise<Object>} 情绪分析结果
     */
    async analyzeEmotion(text) {
        try {
            const response = await fetch(`${this.apiBaseUrl}/analyze/emotion`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    text: text
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data;
        } catch (error) {
            console.error('情绪分析失败:', error);
            throw error;
        }
    }

    /**
     * 发送消息给诗人API
     * @param {string} message - 用户消息
     * @param {string} userId - 用户ID
     * @param {string} sessionId - 会话ID
     * @returns {Promise<Object>} API响应
     */
    async sendMessageToPoet(message, userId = 'user_001', sessionId = 'session_001') {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/chat`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    message: message,
                    user_id: userId,
                    session_id: sessionId
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data;
        } catch (error) {
            console.error('发送消息给诗人失败:', error);
            throw error;
        }
    }

    /**
     * 流式发送消息给诗人API
     * @param {string} message - 用户消息
     * @param {Function} onChunk - 接收数据块的回调
     * @param {string} userId - 用户ID
     * @param {string} sessionId - 会话ID
     */
    async sendMessageToPoetStream(message, onChunk, userId = 'user_001', sessionId = 'session_001') {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/chat/stream`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    message: message,
                    user_id: userId,
                    session_id: sessionId
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const reader = response.body.getReader();
            const decoder = new TextDecoder();

            while (true) {
                const { done, value } = await reader.read();
                if (done) break;

                const chunk = decoder.decode(value);
                const lines = chunk.split('\n');

                for (const line of lines) {
                    if (line.startsWith('data: ')) {
                        const data = line.slice(6);
                        if (data === '[DONE]') {
                            return;
                        }
                        
                        try {
                            const parsed = JSON.parse(data);
                            onChunk(parsed);
                        } catch (e) {
                            console.warn('解析流数据失败:', e);
                        }
                    }
                }
            }
        } catch (error) {
            console.error('流式发送消息给诗人失败:', error);
            throw error;
        }
    }

    /**
     * 切换诗人
     * @param {string} poetId - 诗人ID
     * @returns {Promise<Object>} 切换结果
     */
    async switchPoet(poetId) {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/poet/switch`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    poet_id: poetId
                })
            });

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data;
        } catch (error) {
            console.error('切换诗人失败:', error);
            throw error;
        }
    }

    /**
     * 获取当前诗人
     * @returns {Promise<Object>} 当前诗人信息
     */
    async getCurrentPoet() {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/poet/current`);

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data;
        } catch (error) {
            console.error('获取当前诗人失败:', error);
            throw error;
        }
    }

    /**
     * 获取所有诗人信息
     * @returns {Promise<Array>} 诗人列表
     */
    async getAllPoets() {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/poets`);

            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data.poets;
        } catch (error) {
            console.error('获取诗人列表失败:', error);
            return [];
        }
    }

    /**
     * 获取诗人相关语音列表
     * @returns {Promise<Array>} 语音列表
     */
    async getPoetVoices() {
        try {
            const response = await fetch(`${this.apiBaseUrl}/qwen/voices`);
            
            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data.voices;
        } catch (error) {
            console.error('获取诗人语音列表失败:', error);
            return [];
        }
    }

    /**
     * 获取可用语音列表（从API）
     * @returns {Promise<Array>} 语音列表
     */
    async getVoicesFromAPI() {
        try {
            const response = await fetch(`${this.apiBaseUrl}/voices`);
            
            if (!response.ok) {
                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            const data = await response.json();
            return data.voices;
        } catch (error) {
            console.error('获取语音列表失败:', error);
            return [];
        }
    }

    /**
     * 检查API连接状态
     */
    async checkAPIConnection() {
        try {
            const response = await fetch(ENV_CONFIG.getHealthUrl());
            const wasConnected = this.isConnected;
            this.isConnected = response.ok;
            
            if (wasConnected !== this.isConnected && this.callbacks.onConnectionChange) {
                this.callbacks.onConnectionChange(this.isConnected);
            }
            
            return this.isConnected;
        } catch (error) {
            const wasConnected = this.isConnected;
            this.isConnected = false;
            
            if (wasConnected !== this.isConnected && this.callbacks.onConnectionChange) {
                this.callbacks.onConnectionChange(this.isConnected);
            }
            
            console.error('API连接检查失败:', error);
            return false;
        }
    }

    /**
     * 设置回调函数
     * @param {string} event - 事件名称
     * @param {Function} callback - 回调函数
     */
    on(event, callback) {
        if (this.callbacks.hasOwnProperty(`on${event.charAt(0).toUpperCase()}${event.slice(1)}`)) {
            this.callbacks[`on${event.charAt(0).toUpperCase()}${event.slice(1)}`] = callback;
        }
    }

    /**
     * 移除回调函数
     * @param {string} event - 事件名称
     */
    off(event) {
        if (this.callbacks.hasOwnProperty(`on${event.charAt(0).toUpperCase()}${event.slice(1)}`)) {
            this.callbacks[`on${event.charAt(0).toUpperCase()}${event.slice(1)}`] = null;
        }
    }

    /**
     * 设置语音识别配置
     * @param {Object} config - 配置对象
     */
    setRecognitionConfig(config) {
        Object.assign(this.recognitionConfig, config);
        if (this.recognition) {
            Object.assign(this.recognition, this.recognitionConfig);
        }
    }

    /**
     * 设置语音合成配置
     * @param {Object} config - 配置对象
     */
    setSynthesisConfig(config) {
        Object.assign(this.synthesisConfig, config);
    }

    /**
     * 获取当前状态
     * @returns {Object} 状态信息
     */
    getStatus() {
        return {
            isListening: this.isListening,
            isConnected: this.isConnected,
            hasRecognition: !!this.recognition,
            hasSynthesis: !!this.synthesis,
            availableVoices: this.availableVoices ? this.availableVoices.length : 0
        };
    }

    /**
     * 停止所有语音活动
     */
    stopAll() {
        this.stopListening();
        
        if (this.synthesis) {
            this.synthesis.cancel();
        }
    }

    /**
     * 销毁语音管理器
     */
    dispose() {
        this.stopAll();
        
        // 清理回调
        Object.keys(this.callbacks).forEach(key => {
            this.callbacks[key] = null;
        });
        
        this.recognition = null;
        this.synthesis = null;
    }
}